<html>
<head><meta charset="utf-8"><title>Better supporting Harvard architectures · t-compiler · Zulip Chat Archive</title></head>
<h2>Stream: <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/index.html">t-compiler</a></h2>
<h3>Topic: <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html">Better supporting Harvard architectures</a></h3>

<hr>

<base href="https://rust-lang.zulipchat.com">

<head><link href="https://rust-lang.github.io/zulip_archive/style.css" rel="stylesheet"></head>

<a name="201395082"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/201395082" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#201395082">(Jun 19 2020 at 14:10)</a>:</h4>
<p>For those interested, there's a PR that helps rustc track different address spaces better. This is needed to support AVR. Notably, AVR is the first Harvard architecture that rustc supports (to my knowledge).</p>
<p><a href="https://github.com/rust-lang/rust/pull/73270">https://github.com/rust-lang/rust/pull/73270</a></p>



<a name="201396665"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/201396665" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonas Schievink  [he/him] <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#201396665">(Jun 19 2020 at 14:23)</a>:</h4>
<p>Interesting. How does the AVR support handle data in Flash vs. RAM? Like if I wrote <code>fn f(data: &amp;[u8]) { ... }</code>, what happens if I call that with a slice in RAM and one in Flash? To my knowledge the function would have no way to find out if the pointer points into Flash or RAM.</p>



<a name="201400494"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/201400494" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#201400494">(Jun 19 2020 at 14:52)</a>:</h4>
<p>Honestly, I've avoided thinking about flash <span aria-label="upside down" class="emoji emoji-1f643" role="img" title="upside down">:upside_down:</span> I think that the general answer there is "it doesn't". I think you have to use special instructions to read/write from flash. In the C code, there are functions like <code>{Read,Write}Flash{Byte,Page}</code>.</p>



<a name="201409273"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/201409273" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Josh Triplett <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#201409273">(Jun 19 2020 at 15:59)</a>:</h4>
<p>GCC has a concept of pointer address spaces. In addition to using that for hardware differences, people also use that to tag pointers as requiring special handling.</p>



<a name="201409386"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/201409386" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Josh Triplett <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#201409386">(Jun 19 2020 at 16:00)</a>:</h4>
<p>Such as requiring special functions to handle them.</p>



<a name="201534560"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/201534560" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#201534560">(Jun 21 2020 at 13:32)</a>:</h4>
<p>LLVM has something similar</p>



<a name="201536021"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/201536021" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#201536021">(Jun 21 2020 at 14:17)</a>:</h4>
<p>If you check the PR, it’s “just” having rustc (more) correctly instruct LLVM what address space to use.</p>



<a name="201537721"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/201537721" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#201537721">(Jun 21 2020 at 14:58)</a>:</h4>
<p>makes sense. I suppose that is similar to how C frontends work?</p>



<a name="201537736"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/201537736" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#201537736">(Jun 21 2020 at 14:59)</a>:</h4>
<p>they have the same problem in that the source language does not actually support multiple address spaces</p>



<a name="201544054"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/201544054" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#201544054">(Jun 21 2020 at 17:14)</a>:</h4>
<p>I believe it's similar in concept to what the C frontend would do, but I'm not sure.</p>



<a name="202043069"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043069" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043069">(Jun 26 2020 at 01:03)</a>:</h4>
<p><span class="user-mention" data-user-id="116155">@Jake Goulding</span> <span class="user-mention" data-user-id="314884">@Dylan McKay</span> the PR is giving me a bad feeling, there's too many changes in places that have nothing to do with functions</p>



<a name="202043133"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043133" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043133">(Jun 26 2020 at 01:04)</a>:</h4>
<p>does LLVM not allow passing around a function pointer as a regular pointer (basically an unnecessarily typed <code>usize</code>) as long as you cast it before you call it?</p>



<a name="202043223"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043223" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043223">(Jun 26 2020 at 01:06)</a>:</h4>
<p>I guess I can leave a comment?</p>



<a name="202043255"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043255" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043255">(Jun 26 2020 at 01:07)</a>:</h4>
<p>Hm… I think having the address space attached throughout the IR is desirable…</p>



<a name="202043269"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043269" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043269">(Jun 26 2020 at 01:07)</a>:</h4>
<p>I wonder there are any harvard implementations that allow executing from data addrspaces.</p>



<a name="202043285"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043285" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043285">(Jun 26 2020 at 01:08)</a>:</h4>
<p>(to enable e.g. jit?)</p>



<a name="202043322"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043322" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043322">(Jun 26 2020 at 01:08)</a>:</h4>
<p>actually this is another example of LLVM shooting itself in the foot by putting information into types as opposed to into instructions</p>



<a name="202043345"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043345" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043345">(Jun 26 2020 at 01:09)</a>:</h4>
<p>possibly ^^</p>



<a name="202043358"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043358" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043358">(Jun 26 2020 at 01:09)</a>:</h4>
<p>the only thing the address space could matter for when it's not loaded from/stored to/called, is the pointer size</p>



<a name="202043367"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043367" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043367">(Jun 26 2020 at 01:10)</a>:</h4>
<p>and I suppose LLVM could just have <code>ptr32</code>, <code>ptr64</code>, etc. (or even just <code>p32</code>, <code>p64</code>, etc. :P)</p>



<a name="202043819"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043819" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043819">(Jun 26 2020 at 01:21)</a>:</h4>
<p>left a comment with a suggestion</p>



<a name="202043865"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043865" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043865">(Jun 26 2020 at 01:22)</a>:</h4>
<p><span class="user-mention" data-user-id="123586">@nagisa</span> I now strongly suspect all of their troubles are from us using <code>pointercast</code> "because it looks nicer" when <code>bitcast</code> would be able to change the address space, not just the pointee type</p>



<a name="202043894"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043894" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043894">(Jun 26 2020 at 01:23)</a>:</h4>
<p>I wonder how much of the abandoned attempts to support AMDGPU or w/e could be replaced with just using <code>bitcast</code> everywhere...</p>



<a name="202043900"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043900" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043900">(Jun 26 2020 at 01:23)</a>:</h4>
<p>although if they actually have multiple data address spaces, there isn't really any way to tell them apart for load/store</p>



<a name="202043980"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043980" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043980">(Jun 26 2020 at 01:25)</a>:</h4>
<p>yeh, and that’s why I feel like doing it the way is done in the PR is fairly simple way to get something right, as in pointers just end up carrying their actual addrspace through all sorts of casts…</p>



<a name="202043986"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043986" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043986">(Jun 26 2020 at 01:25)</a>:</h4>
<p>I do wonder what happens if you cast to usize and then back tho</p>



<a name="202043994"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202043994" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202043994">(Jun 26 2020 at 01:25)</a>:</h4>
<p>probably bad things, _somewhere_ in the stack.</p>



<a name="202044315"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044315" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044315">(Jun 26 2020 at 01:32)</a>:</h4>
<p>I don't like preserving address spaces like done in the PR though</p>



<a name="202044323"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044323" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044323">(Jun 26 2020 at 01:33)</a>:</h4>
<p>anything that relies on preservation is bound to break</p>



<a name="202044341"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044341" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044341">(Jun 26 2020 at 01:33)</a>:</h4>
<p>and to me seems to assume that values live in a vacuum, ignoring the loss of information from e.g. storing a pointer into memory then reading it again later</p>



<a name="202044388"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044388" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044388">(Jun 26 2020 at 01:34)</a>:</h4>
<p>I can say it does <em>work</em>, as I just got my async serial port example code to actually work on device</p>



<a name="202044405"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044405" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044405">(Jun 26 2020 at 01:34)</a>:</h4>
<p>if you have some time to waste, can you try my suggestion as a replacement to that PR?</p>



<a name="202044412"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044412" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044412">(Jun 26 2020 at 01:34)</a>:</h4>
<p>lemme find the line to change</p>



<a name="202044443"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044443" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044443">(Jun 26 2020 at 01:35)</a>:</h4>
<p>replace this <a href="https://github.com/rust-lang/rust/blob/master/src/librustc_codegen_llvm/builder.rs#L696">https://github.com/rust-lang/rust/blob/master/src/librustc_codegen_llvm/builder.rs#L696</a></p>
<p>with <code>self.bitcast(val, dest_ty)</code></p>



<a name="202044452"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044452" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044452">(Jun 26 2020 at 01:35)</a>:</h4>
<p>Would be happy, although I'm down to 18% battery so I don't know I'll make it through a rustc compile cycle</p>



<a name="202044454"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044454" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044454">(Jun 26 2020 at 01:35)</a>:</h4>
<p>oh lord</p>



<a name="202044458"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044458" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044458">(Jun 26 2020 at 01:35)</a>:</h4>
<p>brings me back to highschool</p>



<a name="202044506"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044506" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044506">(Jun 26 2020 at 01:36)</a>:</h4>
<p>anyway that's the suggestion, feel free to try it when you have the time/battery</p>



<a name="202044516"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044516" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044516">(Jun 26 2020 at 01:37)</a>:</h4>
<p>to be clear, you want me to not have any of Dylan's patch, and <em>just</em> change that line?</p>



<a name="202044574"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044574" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044574">(Jun 26 2020 at 01:38)</a>:</h4>
<p>yes</p>



<a name="202044595"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044595" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044595">(Jun 26 2020 at 01:39)</a>:</h4>
<p>if it works that means there's no reason to use <code>pointercast</code>, it may look nicer but it's a trap</p>



<a name="202044605"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Better%20supporting%20Harvard%20architectures/near/202044605" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> eddyb <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Better.20supporting.20Harvard.20architectures.html#202044605">(Jun 26 2020 at 01:39)</a>:</h4>
<p>if it doesn't... I'll have to <del>eat my hat</del> go look at the actual definitions in LLVM</p>



<hr><p>Last updated: Aug 07 2021 at 22:04 UTC</p>
</html>